{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# COMPSCI 389: Introduction to Machine Learning\n",
    "# PyTorch and Overfitting\n",
    "\n",
    "This notebook provides an introduction to Pytorch, and discusses the phenomenon of **overfitting**. So far we have covered the use of autograd to automatically differentiate Python functions. While autograd is a powerful tool, it can be quite slow. Since training ML models can be computationally intensive, using autograd for even medium-sized models may be too slow.\n",
    "\n",
    "Other libraries have been developed specifically for automatic differentiation for ML. Two of the most popular libraries are [PyTorch](https://pytorch.org/) and [Tensorflow](https://www.tensorflow.org/). Tensorflow is a product of Google, and integrates nicely with Google's cloud computing platforms. However, it has a steeper learning curve and more verbose syntax. PyTorch is currently more commonly used ([here](https://trends.google.com/trends/explore?date=today%205-y&geo=US&q=tensorflow,pytorch&hl=en) is a comparison using Google Trends). Other altnernatives include [Keras](https://keras.io/), [Caffe](https://caffe.berkeleyvision.org/), and [MXNet](https://mxnet.apache.org/versions/1.9.1/). In this course, we will use PyTorch. \n",
    "\n",
    "PyTorch (and other deep learning libraries) provides a few benefits over autograd:\n",
    "\n",
    "1. It is highly optimized. Whereas autograd executed Python code, PyTorch relies on lower-level compiled implementations of the functions necessary to implement and train artificial neural network models.\n",
    "2. It was designed for training artificial neural networks.\n",
    "    - It includes default implementations of standard layers. For example, you can use high-level scripting languages to add convolutional layers, pooling layers, and fully connected layers. You can also select between pre-defined common loss functions and activation functions.\n",
    "\n",
    "You can install PyTorch with:\n",
    "\n",
    "> pip install torch torchvision"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use the following imports:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# New to this topic:\n",
    "import torch\n",
    "import torch.nn as nn           # For defining our neural network model\n",
    "import torch.optim as optim     # For training the model using data\n",
    "from torch.utils.data import TensorDataset, DataLoader  # For making mini-batches\n",
    "\n",
    "# From before:\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Defining a network architecture (parametric model) in PyTorch\n",
    "\n",
    "Neural network architectures (parametric models) are represented as subclasses that extend `nn.Module` (the base class for all neural network modules in PyTorch). `nn.Module` provides a range of built in functionalities, such as keeping track of trainable parameters, moving parameters and buffers to the GPU for GPU acceleration (more on this later!), saving and loading models, and more.\n",
    "\n",
    "To create a model, we need to define the constructor, `__init__` and a function for computing the output of the model given an input, called `forward` (since this is a forwards pass).\n",
    "\n",
    "- `__init__`: Inside of the constructor, we specify the structure of the parametric model. We do this by defining the different layers that will be used, their sizes, and the different activation functions that will be used.\n",
    "- `forward`: Inside of the forward function, we specify how the different layers are ordered and where the activation functions are applied.\n",
    "\n",
    "We do not need to specify any derivatives or anything about the backwards pass - this is all automatic!\n",
    "\n",
    "We will create a network with three hidden layers. This network is bigger than what is needed for the GPA prediction problem. We are using a relatively large network to better show the advantages of training on a GPU and to show something called \"overfitting\" later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FullyConnectedNetwork(nn.Module):\n",
    "    def __init__(self):\n",
    "        # First call the nn.Module constructor to initialize other parts of the model. Always do this first.\n",
    "        super(FullyConnectedNetwork, self).__init__()\n",
    "\n",
    "        # Define layers. The lines below create the layers (memory is allocated for the weights here).\n",
    "        self.fc1 = nn.Linear(9, 1024)  # First hidden layer with 1024 neurons and 9 inputs.\n",
    "        self.fc2 = nn.Linear(1024, 512) # Second hidden layer with 512 neurons and 1024 inputs.\n",
    "        self.fc3 = nn.Linear(512, 128)  # Third hidden layer with 128 neurons and 512 inputs.\n",
    "        self.fc4 = nn.Linear(128, 1)   # Output layer with 1 neuron and 128 inputs.\n",
    "\n",
    "        # Define activation function. You could skip this step and use nn.ReLU in the forward pass,\n",
    "        # but that would be *slightly* less efficient. For small models it would likely be fine, but\n",
    "        # it's best practice to create the activation function object once in the constructor. Note that\n",
    "        # this object can be re-used any time a ReLU activation function is needed \n",
    "        # (we don't need many relu objects)\n",
    "        self.relu = nn.ReLU()\n",
    "\n",
    "    def forward(self, x):\n",
    "        # Pass data through the network\n",
    "        x = self.relu(self.fc1(x))\n",
    "        x = self.relu(self.fc2(x))\n",
    "        x = self.relu(self.fc3(x))\n",
    "        x = self.fc4(x)                 # No activation after the output layer\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now create an instance of this model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "FullyConnectedNetwork(\n",
      "  (fc1): Linear(in_features=9, out_features=1024, bias=True)\n",
      "  (fc2): Linear(in_features=1024, out_features=512, bias=True)\n",
      "  (fc3): Linear(in_features=512, out_features=128, bias=True)\n",
      "  (fc4): Linear(in_features=128, out_features=1, bias=True)\n",
      "  (relu): ReLU()\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "# Create an instance of the network\n",
    "net = FullyConnectedNetwork()\n",
    "\n",
    "# The network structure is printed as a sanity check\n",
    "print(net)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `bias=True` terms indicates that each perceptron includes an extra feature that is always equal to 1 (and hence one extra weight beyond the number of outputs from the previous layer). This is what we discussed previously when we talked about appending a 1 to the columns of a data set to implement the \"y-intercept\" in linear regression. For perceptrons and neural networks, this extra weight is called the **bias**.\n",
    "\n",
    "Next, let's load the GPA data, split it into training and testing, and standardize it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"https://people.cs.umass.edu/~pthomas/courses/COMPSCI_389/GPA.csv\", delimiter=',') # Read GPA.csv, assuming numbers are separated by commas\n",
    "#df = pd.read_csv(\"data/GPA.csv\", delimiter=',')\n",
    "\n",
    "# We already loaded X and y, but do it again as a reminder\n",
    "X = df.iloc[:, :-1]\n",
    "y = df.iloc[:, -1]\n",
    "\n",
    "# Split the data into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, shuffle=True)\n",
    "\n",
    "# Standardize the features\n",
    "scaler = StandardScaler()\n",
    "X_train = scaler.fit_transform(X_train) # This sets the min/max values from the training data (without looking at the testing)\n",
    "X_test = scaler.transform(X_test)       # This uses the min/max scaling values chosen during training! (transform, not fit_transform)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "PyTorch has its own objects for storing data, called PyTorch tensors. These are simply multidimensional arrays. Let's convert our data to these tensor objects. Note that the `tensor` constructor is not compatible with `pandas.Series` objects, so we call `y_train.values` and `y_test.values` to convert these to `numpy.ndarray` objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert data to PyTorch tensors\n",
    "X_train_tensor = torch.tensor(X_train,        dtype=torch.float32)\n",
    "y_train_tensor = torch.tensor(y_train.values, dtype=torch.float32).view(-1,1)\n",
    "X_test_tensor  = torch.tensor(X_test,         dtype=torch.float32)\n",
    "y_test_tensor  = torch.tensor(y_test.values,  dtype=torch.float32).view(-1,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Above, the `.view(-1,1)` on the labels reshapes the tensor. The first argument says to automatically calculate the size of the first dimension, and the second argument says taht the second dimension should be 1. Without `.view(-1,1)`, the `y_train_tensor` and `y_test_tensor` would be flat 1-dimensional tensors. The built-in MSE loss function that we use later expects a 2-dimensional tensor. The call to `.view(-1,1)` convert the 1-dimensional tensor into a 2-dimensional tensor (that happens to only have one column). Without this line, the training code below should preduce a warning pointing out that a 2-dimensional \"target\" (label) was expected, and that incorrect outputs could result.\n",
    "\n",
    "Note that PyTorch does not have its own functions for reading data from CSV files, nor for performing train-test splits. It is therefore common to use Pandas, Scikit-Learn, and PyTorch together like this.\n",
    "\n",
    "For now, we will keep the data as tensor objects. Later, we will use PyTorch's own dataset representation, `TensorDataset`, which is particularly useful when training on a GPU.\n",
    "\n",
    "Next, let's define the loss function that we would like to minimize (the sample MSE). PyTorch has common loss functions built in, so we do not need to re-implement the loss function ourselves!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_function = nn.MSELoss()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, let's choose an algorithm for solving the optimization problem. There are many built in optimizers. For example, we could perform gradient descent with:\n",
    "\n",
    "```\n",
    "optimizer = optim.SGD(net.parameters(), lr=0.01)\n",
    "```\n",
    "\n",
    "Here, `lr` is the learning rate. We could also include a momentum parameter `momentum=0.9`. Other common optimizers include:\n",
    "\n",
    "1. RMSprop: This is particularly useful for recurrent neural networks.\n",
    "    ```\n",
    "    optimizer = torch.optim.RMSprop(net.parameters(), lr=0.01)\n",
    "    ```\n",
    "2. Adagrad: This is particularly useful for sparse data (data where most values are zero).\n",
    "    ```\n",
    "    optimizer = torch.optim.Adagrad(net.parameters(), lr=0.01)\n",
    "    ```\n",
    "3. Adadelta: This does not require a learning rate parameter.\n",
    "    ```\n",
    "    optimizer = torch.optim.Adadelta(net.parameters())\n",
    "    ```\n",
    "4. AdamW: A variant of Adam that includes weight decay.\n",
    "    ```\n",
    "    optimizer = torch.optim.AdamW(net.parameters(), lr=0.01)\n",
    "    ```\n",
    "5. SGD with momentum:\n",
    "    ```\n",
    "    optimizer = torch.optim.SGD(net.parameters(), lr=0.01, momentum=0.9)\n",
    "    ```\n",
    "\n",
    "We will use the Adam optimizer, which is currently the most popular optimizer for deep learning."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.Adam(net.parameters())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we can run the training loop. For each epoch:\n",
    "\n",
    "1. We will call `net(X_train_tensor)` to run the forward pass for each row in `X_train_tensor`.\n",
    "2. We will Compute the resulting loss. This is a forward pass of the loss function, and is necessary!\n",
    "3. We compute a backward pass starting from the loss function with `loss.backward()`. This computes the gradient with respect to each model parameter.\n",
    "    - **Note**: Each model parameter has a `.grad` attribute storing the gradient of the loss w.r.t. that parameter. When `.backward()` is called, the gradients for each parameter are accumulated in this `.grad` attribute. That is, they are added to whatever is currently stored in `.grad`! This can be useful in more advanced architectures where gradients from different sources are combined. \n",
    "    - This also means that we need to clear the `.grad` parameter at the start of each epoch, so that we do not sum up the gradients across all epochs. This is achieved with `optimizer.zero_grad()`.\n",
    "4. We update the weights using the optimizer via `optimizer.step()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [0/100], Loss: 8.3453\n",
      "Epoch [10/100], Loss: 1.4491\n",
      "Epoch [20/100], Loss: 0.8890\n",
      "Epoch [30/100], Loss: 0.7326\n",
      "Epoch [40/100], Loss: 0.7181\n",
      "Epoch [50/100], Loss: 0.6600\n",
      "Epoch [60/100], Loss: 0.6356\n",
      "Epoch [70/100], Loss: 0.6110\n",
      "Epoch [80/100], Loss: 0.5917\n",
      "Epoch [90/100], Loss: 0.5783\n"
     ]
    }
   ],
   "source": [
    "epochs = 100                    # The number of epochs to run\n",
    "for epoch in range(epochs):\n",
    "    # Zero the gradients\n",
    "    optimizer.zero_grad()\n",
    "    \n",
    "    # Forward pass\n",
    "    y_pred = net(X_train_tensor)\n",
    "\n",
    "    # Compute loss\n",
    "    loss = loss_function(y_pred, y_train_tensor)\n",
    "\n",
    "    # Backward pass and optimize\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "\n",
    "    # Print statistics\n",
    "    if epoch % 10 == 0:\n",
    "        print(f'Epoch [{epoch}/{epochs}], Loss: {loss.item():.4f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On my desktop, this took 32.7 seconds. We will revisit this later.\n",
    "\n",
    "We can then evaluate the learned model on the testing data. When we do this, we do not need to store the gradient information used for training, so we wrap the code in:\n",
    "```\n",
    "with torch.no_grad():\n",
    "    ...\n",
    "```\n",
    "This tells PyTorch that when running the model, it doesn't need to store information during the forward passes. Rather, we will only be using the output of the parametric model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.5853\n"
     ]
    }
   ],
   "source": [
    "# Evaluate the model with test data\n",
    "with torch.no_grad():\n",
    "    y_pred_test = net(X_test_tensor)\n",
    "    test_loss = loss_function(y_pred_test, y_test_tensor)\n",
    "    print(f'Test Loss: {test_loss.item():.4f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice:\n",
    "1. This may be slower than training the linear parametric model. That isn't because PyTorch is slower than AutoGrad, but rather because we're training a significantly more complex model.\n",
    "2. This was running on the CPU. PyTorch automatically uses multithreading, so it used all of the available cores during training.\n",
    "\n",
    "### Training ML Models on the GPU\n",
    "\n",
    "For such a small model, training on the CPU is sufficient. For bigger models and data sets, you may want to train on the GPU. In class we will discuss the benefits of training ML models on the GPU. PyTorch makes training on the GPU relatively simple. We simply need to:\n",
    "\n",
    "1. Install CUDA. You can download the \"CUDA Toolkit\" from NVIDIA [here](https://developer.nvidia.com/cuda-toolkit). Before doing so, look at the versions of CUDA that PyTorch supports using the link in the next instruction. Right now, the latest version is CUDA 12.1, which you can download [here](https://developer.nvidia.com/cuda-12-1-0-download-archive).\n",
    "2. Confirm that your PyTorch installation is compatible with your version of CUDA. You can get the appropriate PyTorch installation commands for your version of CUDA [here](https://pytorch.org/get-started/locally/). For example, if you want PyTorch 2.2.1 on Windows, installed using pip, and using Cuda 12.1, the installation command is:\n",
    "    > pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121\n",
    "3. In the code:\n",
    "    - Check if CUDA (GPU support) is available.\n",
    "        > device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "    - Move the network to the GPU.\n",
    "        > net.to(device)\n",
    "    - Move the training data to the GPU.\n",
    "        > X_train_tensor = X_train_tensor.to(device)\n",
    "        \n",
    "        > y_train_tensor = y_train_tensor.to(device)\n",
    "    - When we are done training the model, we can then move it back to the CPU:\n",
    "        > net.to('cpu')\n",
    "\n",
    "We can do all of this with the following lines:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda')"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [0/100], Loss: 8.6576\n",
      "Epoch [10/100], Loss: 1.3355\n",
      "Epoch [20/100], Loss: 1.0290\n",
      "Epoch [30/100], Loss: 0.7493\n",
      "Epoch [40/100], Loss: 0.7279\n",
      "Epoch [50/100], Loss: 0.6782\n",
      "Epoch [60/100], Loss: 0.6503\n",
      "Epoch [70/100], Loss: 0.6216\n",
      "Epoch [80/100], Loss: 0.6011\n",
      "Epoch [90/100], Loss: 0.5857\n"
     ]
    }
   ],
   "source": [
    "net = FullyConnectedNetwork()               # Create a new network to train from scratch\n",
    "optimizer = optim.Adam(net.parameters())    # Create the optimizer for this network\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")   # Check if CUDA (GPU) available\n",
    "display(device)                             # Confirm that the GPU is being used\n",
    "\n",
    "net.to(device)                              # Move the network to GPU if available\n",
    "X_train_tensor = X_train_tensor.to(device)  # Also move the tensors to the chosen device\n",
    "y_train_tensor = y_train_tensor.to(device)\n",
    "\n",
    "epochs = 100                                # Number of epochs\n",
    "for epoch in range(epochs):\n",
    "    optimizer.zero_grad()                   # Zero the gradients\n",
    "    y_pred = net(X_train_tensor)            # Forward pass\n",
    "    loss = loss_function(y_pred, y_train_tensor)    # Compute the loss for printing/plotting\n",
    "    loss.backward()                         # Backwards pass\n",
    "    optimizer.step()                        # Update the weights using the optimizer\n",
    "    if epoch % 10 == 0:                     # Print statistics\n",
    "        print(f'Epoch [{epoch}/{epochs}], Loss: {loss.item():.4f}')\n",
    "\n",
    "net.to('cpu');                              # Move the model back to the CPU"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wow, that was fast! It took 2.6 seconds (GPU/CUDA) rather than more than 32.7 seconds (CPU)! For bigger models and data sets, this improvement can be even more extreme. In class we will discuss why it is often faster to train large ML models on the GPU. For now, let's confirm that we get a similar MSE on the testing set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.5872\n"
     ]
    }
   ],
   "source": [
    "# Evaluate the model with test data (optional)\n",
    "with torch.no_grad():\n",
    "    y_pred_test = net(X_test_tensor)\n",
    "    test_loss = loss_function(y_pred_test, y_test_tensor)\n",
    "    print(f'Test Loss: {test_loss.item():.4f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using mini-batches\n",
    "\n",
    "As we saw before, mini-batches can speed up optimization, resulting in better model parameters from fewer epochs. PyTorch provides a `DataLoader` class that can be used to automatically divide data into mini-batches. \n",
    "\n",
    "In order to use a DataLoader, we need to convert the data set into a TensorDataset. We do this with:\n",
    "```\n",
    "train_dataset = TensorDataset(X_train_tensor, y_train_tensor)\n",
    "```\n",
    "\n",
    "We can then create the DataLoader object with:\n",
    "```\n",
    "train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)\n",
    "```\n",
    "\n",
    "This DataLoader object is the standard method for passing data to a model that is being trained on a GPU. It simplifies a few things:\n",
    "1. It provides methods for performing batching (using mini-batches).\n",
    "2. It provides methods for shuffling the data\n",
    "3. It can use multiple threads to prepare and send data to the model. This is useful for very large data sets.\n",
    "    - This also minimizes the time that the GPU spends waiting for data to be provided.\n",
    "\n",
    "For example, we can iterate over batches within an epoch with:\n",
    "```\n",
    "for X_batch, y_batch in train_loader:\n",
    "```\n",
    "We can then move these batches to the GPU with:\n",
    "```\n",
    "X_batch, y_batch = X_batch.to(device), y_batch.to(device)\n",
    "```\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [0/100], Average Loss: 0.6923\n",
      "Epoch [10/100], Average Loss: 0.5668\n",
      "Epoch [20/100], Average Loss: 0.5559\n",
      "Epoch [30/100], Average Loss: 0.5470\n",
      "Epoch [40/100], Average Loss: 0.5356\n",
      "Epoch [50/100], Average Loss: 0.5185\n",
      "Epoch [60/100], Average Loss: 0.4981\n",
      "Epoch [70/100], Average Loss: 0.4797\n",
      "Epoch [80/100], Average Loss: 0.4556\n",
      "Epoch [90/100], Average Loss: 0.4359\n"
     ]
    }
   ],
   "source": [
    "net = FullyConnectedNetwork()\n",
    "optimizer = optim.Adam(net.parameters())\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "net.to(device)\n",
    "\n",
    "# Create a TensorDataset and DataLoader\n",
    "train_dataset = TensorDataset(X_train_tensor, y_train_tensor)\n",
    "train_loader = DataLoader(dataset=train_dataset, batch_size=100, shuffle=True)\n",
    "\n",
    "epochs = 100\n",
    "for epoch in range(epochs):\n",
    "    total_loss = 0.0    # To sum the loss over all batches\n",
    "    num_batches = 0     # A lazy way to get the number of batches: count them\n",
    "    for X_batch, y_batch in train_loader:                           # Iterate over mini-batches\n",
    "        X_batch, y_batch = X_batch.to(device), y_batch.to(device)   # Move batches to GPU\n",
    "        optimizer.zero_grad()\n",
    "        y_pred = net(X_batch)\n",
    "        loss = loss_function(y_pred, y_batch)\n",
    "        total_loss += loss.item()\n",
    "        num_batches += 1\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "    # Calculate the average loss over all mini-batches in this epoch\n",
    "    average_loss = total_loss / num_batches\n",
    "\n",
    "    if epoch % 10 == 0: # Print statistics\n",
    "        print(f'Epoch [{epoch}/{epochs}], Average Loss: {average_loss:.4f}')\n",
    "net.to('cpu');  # Move the model back to CPU if needed\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While 100 epochs took longer, far more gradient updates where performed. Notice that the training loss reached lower values in far fewer epochs. So, the \"time to complete 100 epochs\" is not a particularly fair metric.\n",
    "\n",
    "Below we compute the loss on the held out testing set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test Loss: 0.7318\n"
     ]
    }
   ],
   "source": [
    "# Evaluate the model with test data (optional)\n",
    "with torch.no_grad():\n",
    "    y_pred_test = net(X_test_tensor)\n",
    "    test_loss = loss_function(y_pred_test, y_test_tensor)\n",
    "    print(f'Test Loss: {test_loss.item():.4f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the training loss was significantly lower than the testing loss. We observed this previously with the nearest neighbor methods. Let's investigate this further by plotting the training and testing loss after each epoch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [0/100], Training Loss: 0.6952, Testing Loss: 0.5909\n",
      "Epoch [10/100], Training Loss: 0.5657, Testing Loss: 0.5853\n",
      "Epoch [20/100], Training Loss: 0.5565, Testing Loss: 0.6122\n",
      "Epoch [30/100], Training Loss: 0.5487, Testing Loss: 0.5915\n",
      "Epoch [40/100], Training Loss: 0.5362, Testing Loss: 0.6002\n",
      "Epoch [50/100], Training Loss: 0.5193, Testing Loss: 0.6233\n",
      "Epoch [60/100], Training Loss: 0.4986, Testing Loss: 0.6340\n",
      "Epoch [70/100], Training Loss: 0.4755, Testing Loss: 0.6614\n",
      "Epoch [80/100], Training Loss: 0.4476, Testing Loss: 0.6838\n",
      "Epoch [90/100], Training Loss: 0.4200, Testing Loss: 0.7116\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create a new network to train (the old one already had trained weights, and we want to start from scratch).\n",
    "net = FullyConnectedNetwork()\n",
    "\n",
    "# Create the optimizer for this new network\n",
    "optimizer = optim.Adam(net.parameters())\n",
    "\n",
    "# Check if CUDA (GPU support) is available\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Move the network into GPU if available\n",
    "net.to(device)\n",
    "\n",
    "# Send the testing data to the GPU\n",
    "X_test_tensor = X_test_tensor.to(device)\n",
    "y_test_tensor = y_test_tensor.to(device)\n",
    "\n",
    "# Convert the training and testing data to TensorDatasets\n",
    "train_dataset = TensorDataset(X_train_tensor, y_train_tensor)\n",
    "\n",
    "# Create a DataLoader to handle mini-batch loading\n",
    "batch_size = 100\n",
    "train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True)\n",
    "\n",
    "epochs = 100  # Number of epochs\n",
    "training_losses = []\n",
    "testing_losses = []\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    net.train()  # Set the network into training mode\n",
    "\n",
    "    # We will track the total loss across all mini-batches in this epoch\n",
    "    total_loss = 0.0\n",
    "    num_batches = 0\n",
    "\n",
    "    for X_batch, y_batch in train_loader:\n",
    "        # Move batches to the same device as model\n",
    "        X_batch, y_batch = X_batch.to(device), y_batch.to(device)\n",
    "\n",
    "        # Zero the gradients\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        # Forward pass\n",
    "        y_pred = net(X_batch)\n",
    "\n",
    "        # Compute loss\n",
    "        loss = loss_function(y_pred, y_batch)\n",
    "        total_loss += loss.item()\n",
    "        num_batches += 1\n",
    "\n",
    "        # Backward pass and update\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "    # Calculate the average loss over all mini-batches in this epoch\n",
    "    average_train_loss = total_loss / num_batches\n",
    "    training_losses.append(average_train_loss)\n",
    "\n",
    "    # Evaluate the model on the test data\n",
    "    net.eval()  # Set the network to evaluation mode\n",
    "    with torch.no_grad():\n",
    "        # Forward pass on the entire test data\n",
    "        y_pred_test = net(X_test_tensor)\n",
    "\n",
    "        # Compute the loss on the entire test data\n",
    "        test_loss = loss_function(y_pred_test, y_test_tensor).item()\n",
    "        testing_losses.append(test_loss)\n",
    "\n",
    "    if epoch % 10 == 0:\n",
    "        print(f'Epoch [{epoch}/{epochs}], Training Loss: {average_train_loss:.4f}, Testing Loss: {test_loss:.4f}')\n",
    "\n",
    "# Plotting the training and testing losses\n",
    "plt.plot(training_losses, label='Training Loss')\n",
    "plt.plot(testing_losses, label='Testing Loss')\n",
    "plt.xlabel('Epoch')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Training and Testing Loss Over Epochs')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Overfitting\n",
    "\n",
    "Notice that the error on the training set keeps decreasing, but the error on the testing set increases! This is a phenomenon called **overfitting**, which will be discussed in lecture. Below are some relevant plots for this discussion.\n",
    "\n",
    "First, we plot 10 points from the line $y=x$ with Gaussian noise added:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAHHCAYAAACRAnNyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAxb0lEQVR4nO3de1RU9f7/8dcwclfwAiokCJGXVLx8RbtYZl9RMrXUMm8Z6ck6hRZarpOdr6mdlKzj5WSm2UW7aNnXNMuTJ7HUvqYmarW0jmYG5VG8UAYmhBOzf3/4Y2pEFApmf8DnYy2Waz6z5zPveTu4X+792TMOy7IsAQAAGMjP7gIAAADKQ1ABAADGIqgAAABjEVQAAICxCCoAAMBYBBUAAGAsggoAADAWQQUAABiLoAIAAIxFUEGts3HjRjkcDm3cuNHuUry8+uqrat26tfz9/VW/fn27y4FNHA6Hpk6dancZVSIuLk533nmn3WWgliOooMZYsmSJHA6H5ycoKEgtW7bU2LFjdfTo0Sp5jvfee69adiJ79+7VnXfeqYSEBD3//PNatGhRlT9HbVdcXKx58+bpmmuuUYMGDRQQEKDo6GjddNNNev3111VSUmJ3iQCqQR27CwAq67HHHlN8fLx+/vlnbd68WQsWLNB7772nPXv2KCQk5A/N/d5772n+/PlVHlY2btwot9utf/zjH7rsssuqdO6LwfHjx9WnTx/t3LlTKSkp+p//+R81bNhQR44c0fr16zV8+HB9/fXXmjx5st2lXlBRUZHq1Kkd//Tu27dPfn78fxfVq3b8tuCi0qdPHyUlJUmS7rrrLjVq1EizZ8/W6tWrNWzYMJurO7djx45J0kV9ymfq1KlasmSJcnJyKv3YkSNH6tNPP9Vbb72lQYMGed03adIk7dixQ/v27auiSqtXUFCQ3SVUmcDAQLtLwEWAKIwa77//+78lSdnZ2efd7n//93/VuXNnBQcHKyIiQrfffrsOHTrkuf/OO+/U/PnzJcnrFNOFPPvss2rbtq0CAwMVHR2ttLQ0/fjjj5774+LiNGXKFElSZGTkedcoLF68WA6HQ59++mmZ+2bMmCGn0+lVc3WxLEvXX3+9IiMjPSFLkk6fPq3ExEQlJCTo1KlT1V6HJG3dulXvv/++7r777jIhpVRSUpJGjBjhVeejjz6qzp07Kzw8XKGhobr22mu1YcMGr8eVt54pJydHDodDS5Ys8YwdOXJEo0aNUrNmzRQYGKioqCjdfPPNXsFrx44dSklJUUREhIKDgxUfH6/Ro0d7zX323/+3336r++67T61atVJwcLAaNWqkwYMHlwl0pac+P/74Y02YMEGRkZEKDQ3VwIEDdfz48Qv28c4771TdunV16NAhDRgwQHXr1lVkZKQeeuihMqfNTp06pQcffFAxMTEKDAxUq1at9Pe//12WZXltd/YaFZfLpWnTpqlFixYKCgpSo0aNdM011ygzM9PrcXv37tWtt96qhg0bKigoSElJSXrnnXcu+BpwceKICmq8AwcOSJIaNWpU7jZLlizRqFGj1KVLF2VkZOjo0aP6xz/+oY8//liffvqp6tevr3vuuUeHDx9WZmamXn311Qo999SpUzVt2jQlJyfr3nvv1b59+7RgwQJlZWXp448/lr+/v+bOnatXXnlFq1at0oIFC1S3bl21b9/+nPPdeuutSktL09KlS9WpUyev+5YuXaoePXrokksuKbcel8ul/Pz8CtXesGHDcg/bOxwOvfTSS2rfvr3+/Oc/a+XKlZKkKVOm6IsvvtDGjRsVGhpaoef5o959911J0u23317hxxQUFOiFF17QsGHDNGbMGJ08eVIvvviiUlJStH37dnXs2LHSddxyyy364osvNG7cOMXFxenYsWPKzMzUd99957ndu3dvRUZG6uGHH1b9+vWVk5Pj6V15srKytGXLFg0dOlTNmjVTTk6OFixYoB49eujLL78sczpz3LhxatCggaZMmaKcnBzNnTtXY8eO1fLlyy/4GkpKSpSSkqIrrrhCf//737V+/XrNmjVLCQkJuvfeeyWdCak33XSTNmzYoD/96U/q2LGj3n//fU2cOFGHDh3SnDlzyp1/6tSpysjI0F133aWuXbuqoKBAO3bs0K5du9SrVy9J0hdffKFu3brpkksu0cMPP6zQ0FC9+eabGjBggN566y0NHDjwgq8DFxkLqCEWL15sSbLWr19vHT9+3Dp48KD1xhtvWI0aNbKCg4Ot//znP5ZlWdaGDRssSdaGDRssy7Ks06dPW40bN7batWtnFRUVeeZbs2aNJcl69NFHPWNpaWlWRX8tjh07ZgUEBFi9e/e2SkpKPOPPPPOMJcl66aWXPGNTpkyxJFnHjx+/4LzDhg2zoqOjvebctWuXJclavHjxeR9b+tor8pOdnX3BWp577jlLkvXaa69Z27Zts5xOp5Wenn7Bx53LlClTrObNm1f6cQMHDrQkWT/++KPXeFFRkXX8+HHPz4kTJzz3/fLLL1ZxcbHX9idOnLCaNGlijR492jN29nulVHZ2tle/T5w4YUmynnrqqXLrXLVqlSXJysrKOu/rkWRNmTLFc7uwsLDMNlu3brUkWa+88opnrPT9n5ycbLndbs/4+PHjLafTWaY/Z0tNTbUkWY899pjXeKdOnazOnTt7br/99tuWJOvxxx/32u7WW2+1HA6H9fXXX3vGmjdvbqWmpnpud+jQwerbt+956+jZs6eVmJho/fzzz54xt9ttXX311VaLFi3O+1hcnDj1gxonOTlZkZGRiomJ0dChQ1W3bl2tWrWq3CMNO3bs0LFjx3Tfffd5rQ/o27evWrdurX/+85+/q47169fr9OnTSk9P9zoyMWbMGIWFhf3uee+44w4dPnzY6zTF0qVLFRwcrFtuueW8j+3QoYMyMzMr9NO0adML1nL33XcrJSVF48aN08iRI5WQkKAZM2ZU6HXk5eV5/RQWFsrtdpcZLy4uPu88BQUFkqS6det6jS9cuFCRkZGen2uuucZzn9PpVEBAgCTJ7Xbrhx9+0C+//KKkpCTt2rWrQvX/VnBwsAICArRx40adOHHinNuUrj9as2aNXC5XpeYu5XK59P333+uyyy5T/fr1z1nr3Xff7XVK8tprr1VJSYm+/fbbCj3fn//8Z6/b1157rb755hvP7ffee09Op1P333+/13YPPvigLMvS2rVry527fv36+uKLL7R///5z3v/DDz/oww8/1G233aaTJ0963gPff/+9UlJStH//fp+c2kTNwqkf1Djz589Xy5YtVadOHTVp0kStWrU675UHpf+At2rVqsx9rVu31ubNm39XHeXNGxAQoEsvvbTCO46z9erVS1FRUVq6dKl69uwpt9ut119/XTfffLPq1at33sc2aNBAycnJv+t5y/Piiy8qISFB+/fv15YtW7x2rOcTGRlZofHFixef97M4Sl/zTz/9pPDwcM/4Lbfconbt2kk6sxM9e53Fyy+/rFmzZmnv3r1ewSE+Pr5C9f9WYGCgZs6cqQcffFBNmjTRlVdeqX79+umOO+7wBL7rrrtOt9xyi6ZNm6Y5c+aoR48eGjBggIYPH37eRadFRUXKyMjQ4sWLdejQIa91IOc6jRcbG+t1u0GDBpJUboD6raCgoDL9b9Cggddjv/32W0VHR5d5r11++eWe+8vz2GOP6eabb1bLli3Vrl073XDDDRo5cqTnVOfXX38ty7I0efLkcq/QOnbs2HlPb+LiQ1BBjdO1a1fPVT+1kdPp1PDhw/X888/r2Wef1ccff6zDhw9XaI3G6dOn9cMPP1ToeSIjI+V0Oi+43caNGz1HPXbv3q2rrrqqQvOfvYDylVde0bp16/Taa695jbdt2/a887Ru3VqStGfPHnXr1s0zHhMTo5iYGElndrZ5eXme+1577TXdeeedGjBggCZOnKjGjRvL6XQqIyPDs6ZJUrmLpc/1mSzp6enq37+/3n77bb3//vuaPHmyMjIy9OGHH6pTp05yOBxasWKFtm3bpnfffVfvv/++Ro8erVmzZmnbtm1ljgiVGjdunBYvXqz09HRdddVVCg8Pl8Ph0NChQ+V2u8tsX97fmXXWQtdzqcjf9x/RvXt3HThwQKtXr9a6dev0wgsvaM6cOVq4cKHuuusuz+t56KGHlJKScs45uHwfZyOooNZr3ry5pDOf+VB6hVCpffv2ee6Xyt9xXWjeSy+91DN++vRpZWdn/6EjG3fccYdmzZqld999V2vXrlVkZGS5/7D/1pYtW3T99ddX6Dmys7MVFxd33m1yc3M1btw49e7dWwEBAZ4dzG97Vp6zX//mzZsVFBRU6b7069dPTzzxhJYuXeoVVM5nxYoVuvTSS7Vy5Uqvv9PSq69KlR6N+O1VWlL5Rw0SEhL04IMP6sEHH9T+/fvVsWNHzZo1yyt8XXnllbryyis1ffp0LVu2TCNGjNAbb7yhu+66q9xaU1NTNWvWLM/Yzz//XKYmX2nevLnWr1+vkydPeh1V2bt3r+f+82nYsKFGjRqlUaNG6aefflL37t01depU3XXXXZ7fE39//yo/8ofaizUqqPWSkpLUuHFjLVy40Gs9xNq1a/Xvf/9bffv29YyVXslSkZ1EcnKyAgIC9PTTT3v9b/bFF19Ufn6+17yV1b59e7Vv314vvPCC3nrrLQ0dOrRCHxJW1WtUxowZI7fbrRdffFGLFi1SnTp19Kc//alC/3uvKt26dVOvXr20aNEirV69+pzbnF1P6ZGD345/8skn2rp1q9d2zZs3l9Pp1EcffeQ1/uyzz3rdLiws1M8//+w1lpCQoHr16nneUydOnChTR+nVRedbh+N0Oss8bt68ebZ90u6NN96okpISPfPMM17jc+bMkcPhUJ8+fcp97Pfff+91u27durrssss8r79x48bq0aOHnnvuOeXm5pZ5fEUus8bFhyMqqPX8/f01c+ZMjRo1Stddd52GDRvmuTw5Li5O48eP92zbuXNnSdL999+vlJQUOZ1ODR069JzzRkZGatKkSZo2bZpuuOEG3XTTTdq3b5+effZZdenSpVKX057LHXfcoYceekhSxS/Nrco1KosXL9Y///lPLVmyRM2aNZN0Zgd6++23a8GCBbrvvvuq5Hkq4rXXXtMNN9ygAQMGqE+fPkpOTlaDBg08n0z70Ucfee1A+/Xrp5UrV2rgwIHq27evsrOztXDhQrVp00Y//fSTZ7vw8HANHjxY8+bNk8PhUEJCgtasWeP12TGS9NVXX6lnz5667bbb1KZNG9WpU0erVq3S0aNHPe+Pl19+Wc8++6wGDhyohIQEnTx5Us8//7zCwsJ04403lvva+vXrp1dffVXh4eFq06aNtm7dqvXr15/3cvvq1L9/f11//fX661//qpycHHXo0EHr1q3T6tWrlZ6eroSEhHIf26ZNG/Xo0UOdO3dWw4YNtWPHDq1YsUJjx471bDN//nxdc801SkxM1JgxY3TppZfq6NGj2rp1q/7zn//o888/98XLRE1i1+VGQGWVXp55ocs/y7vkdPny5VanTp2swMBAq2HDhtaIESM8lzSX+uWXX6xx48ZZkZGRlsPhqNClys8884zVunVry9/f32rSpIl17733el0qa1mVuzy5VG5uruV0Oq2WLVtW+DFV5eDBg1Z4eLjVv3//MvcNHDjQCg0Ntb755ptKzfl7L08uVVRUZM2dO9e66qqrrLCwMKtOnTpW06ZNrX79+llLly61fvnlF8+2brfbmjFjhtW8eXMrMDDQ6tSpk7VmzRorNTW1TA3Hjx+3brnlFiskJMRq0KCBdc8991h79uzxujw5Ly/PSktLs1q3bm2FhoZa4eHh1hVXXGG9+eabnnl27dplDRs2zIqNjbUCAwOtxo0bW/369bN27Njh9Xw66/LkEydOWKNGjbIiIiKsunXrWikpKdbevXvLXPpb3vu/vPf72VJTU63Q0NAy46Xvzd86efKkNX78eCs6Otry9/e3WrRoYT311FNel0VbVtnLkx9//HGra9euVv369a3g4GCrdevW1vTp063Tp097Pe7AgQPWHXfcYTVt2tTy9/e3LrnkEqtfv37WihUrzvsacHFyWJYPj+ECqLC8vDxFRUXp0UcfrRHfYQMA1YE1KoChlixZopKSEo0cOdLuUgDANqxRAQzz4Ycf6ssvv9T06dM1YMCAC16ZAwC1Gad+AMP06NFDW7ZsUbdu3fTaa6/x4VcALmoEFQAAYCzWqAAAAGMRVAAAgLFq9GJat9utw4cPq169epX66HMAAGAfy7J08uRJRUdHn/dLZaUaHlQOHz7s+VIyAABQsxw8eNDzydflqdFBpfQLsw4ePKiwsLAqndvlcmndunXq3bu3/P39q3Ru/Io++wZ99g367Bv02Xeqq9cFBQWKiYnx+uLL8tTooFJ6uicsLKxagkpISIjCwsL4RahG9Nk36LNv0GffoM++U929rsiyDRbTAgAAYxFUAACAsQgqAADAWAQVAABgLIIKAAAwFkEFAAAYi6ACAACMRVABAADGIqgAAABjEVQAAICxCCoAAMBYBBUAAHBORwt+9vrTDgQVAACqWG5+kbYcyFNufpHdpfxuy7O+U685myRJveZs0vKs72ypo0Z/ezIAAKZZnvWdJq3cLbcl+TmkjEGJGtIl1u6yKiU3v0iTVu6W//8/nOG2pEdW7lH3lpGKCg/2aS0cUQEAoIqU7uDd1pnbpTv4mnZkJTvvlOc1lCqxLOXkFfq8FoIKAABVxKQd/B8RHxEqP4f3mNPhUFxEiM9rIagAAFBFTNrB/xFR4cHKGJQop+PMi3E6HJoxqJ3PT/tIBBUAAKqMSTv4P2pIl1itG99dkrRufHfb1tmwmBYAgCo0pEusureMVE5eoeIiQmpkSCnVJCzI6087EFQAAKhiUeHBNTqgmIRTPwAAwFgEFQAAYCyCCgAAMBZBBQAAGIugAgAAjEVQAQAAxiKoAAAAYxFUAACAsQgqAADAWAQVAABgLIIKAAAwFkEFAAAYi6ACAACMRVABAADGIqgAAABjEVQAAICxCCoAAMBYBBUAAGAsggoAADAWQQUAABiLoAIAAIxFUAEAAMYiqAAAAGMRVAAAgLEIKgAAwFgEFQAAYCyCCgAAMBZBBQAAGIugAgAAjEVQAQAAxiKoAAAAYxFUAACAsQgqAADAWAQVAABgLIIKAAAwFkEFAAAYi6ACAACMRVABAADGsjWolJSUaPLkyYqPj1dwcLASEhL0t7/9TZZl2VkWAAAwRB07n3zmzJlasGCBXn75ZbVt21Y7duzQqFGjFB4ervvvv9/O0gAAgAFsDSpbtmzRzTffrL59+0qS4uLi9Prrr2v79u12lgUAAAxha1C5+uqrtWjRIn311Vdq2bKlPv/8c23evFmzZ88+5/bFxcUqLi723C4oKJAkuVwuuVyuKq2tdL6qnhfe6LNv0GffoM++QZ99p7p6XZn5HJaNC0LcbrceeeQRPfnkk3I6nSopKdH06dM1adKkc24/depUTZs2rcz4smXLFBISUt3lAgCAKlBYWKjhw4crPz9fYWFh593W1qDyxhtvaOLEiXrqqafUtm1bffbZZ0pPT9fs2bOVmppaZvtzHVGJiYlRXl7eBV9oZblcLmVmZqpXr17y9/ev0rnxK/rsG/TZN+izb9Bn36muXhcUFCgiIqJCQcXWUz8TJ07Uww8/rKFDh0qSEhMT9e233yojI+OcQSUwMFCBgYFlxv39/avtzVqdc+NX9Nk36LNv0GffoM++U9W9rsxctl6eXFhYKD8/7xKcTqfcbrdNFQEAAJPYekSlf//+mj59umJjY9W2bVt9+umnmj17tkaPHm1nWQAAwBC2BpV58+Zp8uTJuu+++3Ts2DFFR0frnnvu0aOPPmpnWQAAwBC2BpV69epp7ty5mjt3rp1lAAAAQ/FdPwAAwFgEFQAAYCyCCgAAMBZBBQAAGIugAgAAjEVQAQAAxiKoAAAAYxFUAACAsQgqAADAWAQVAABgLIIKAAAwFkEFAAAYi6ACAACMRVABAADGIqgAAABjEVQAAICxCCoAAMBYBBUAAGAsggoAADAWQQUAABiLoAIAAIxFUAEAAMYiqAAAAGMRVAAAgLEIKgBQw+XmF2nLgTzl5hfZXQpQ5erYXQAA4PdbnvWdJq3cLbcl+TmkjEGJGtIl1u6ygCrDERUAqKFy84s8IUWS3Jb0yMo9HFlBrUJQAYAaKjvvlCeklCqxLOXkFdpTEFANCCoAUEPFR4TKz+E95nQ4FBcRYk9BQDUgqABADRUVHqyMQYlyOs6kFafDoRmD2ikqPNjmyoCqw2JaAKjBhnSJVfeWkcrJK1RcRAghBbUOQQUAario8GACCmotTv0AAABjEVQAAICxCCoAAMBYBBUAAGAsggoAADAWQQUAABiLoAIAAIxFUAEAAMYiqAAAAGMRVAAAgLEIKgAAwFgEFQAAYCyCCgAAMBZBBQAAGIugAgAAjEVQAQAAxiKoAAAAYxFUAACAsQgqAADAWAQVAABgLIIKAAAwFkEFAAAYi6ACAACMRVABAADGIqgAAABj2R5UDh06pNtvv12NGjVScHCwEhMTtWPHDrvLAgAABqhj55OfOHFC3bp10/XXX6+1a9cqMjJS+/fvV4MGDewsCwAAGMLWoDJz5kzFxMRo8eLFnrH4+HgbKwJQEbn5RcrOO6X4iFBFhQfbXQ6AWszWoPLOO+8oJSVFgwcP1qZNm3TJJZfovvvu05gxY865fXFxsYqLiz23CwoKJEkul0sul6tKayudr6rnhTf67BtV2eeVu/6jqe9+Ibcl+Tmkqf3batB/NfvD89YGvJ99gz77TnX1ujLzOSzLsqr02SshKChIkjRhwgQNHjxYWVlZeuCBB7Rw4UKlpqaW2X7q1KmaNm1amfFly5YpJCSk2usFAAB/XGFhoYYPH678/HyFhYWdd1tbg0pAQICSkpK0ZcsWz9j999+vrKwsbd26tcz25zqiEhMTo7y8vAu+0MpyuVzKzMxUr1695O/vX6Vz41f02Teqqs+fZH+vP71cdrH7S6ld1DW+4R8psVbg/ewb9Nl3qqvXBQUFioiIqFBQsfXUT1RUlNq0aeM1dvnll+utt9465/aBgYEKDAwsM+7v719tb9bqnBu/os++8Uf7nNAkXC63Q+7f/PfG6XDo0iZh/P39Bu9n36DPvlPVva7MXLZentytWzft27fPa+yrr75S8+bNbaoIwPlEhQcrY1CinA6HpDMhZcagdiyoBVBtbD2iMn78eF199dWaMWOGbrvtNm3fvl2LFi3SokWL7CwLwHkM6RKr7i0jlZNXqLiIEEIKgGpla1Dp0qWLVq1apUmTJumxxx5TfHy85s6dqxEjRthZFoALiAoPJqAA8Albg4ok9evXT/369bO7DAAAYCDbP0IfAACgPAQVAABgLIIKAAAwFkEFAAAYi6ACAACMRVABAADGIqgAAABjEVQAAICxCCoAAMBYBBUAAGAsggoAADAWQQUAABiLoAIAAIxFUAEAAMYiqAAAAGMRVAAAgLEIKgAAwFgEFQAAYCyCCgAAMBZBBQAAGIugAgAwQm5+kbYcyFNufpHdpcAgdewuAACA5VnfadLK3XJbkp9DyhiUqCFdYu0uCwbgiAoAwFa5+UWekCJJbkt6ZOUejqxAEkEFAGCz7LxTnpBSqsSylJNXaE9BMApBBQBgq/iIUPk5vMecDofiIkLsKQhGIagAAGwVFR6sjEGJcjrOpBWnw6EZg9opKjzY5spgAhbTAgBsN6RLrLq3jFROXqHiIkIIKfAgqAAAjBAVHkxAQRmc+gEAAMYiqAAAAGMRVAAAgLEIKgAAwFgEFQAAYCyCCgAAMBZBBQAAGIugAgAAjEVQAQAAxiKoAAAAYxFUAACAsQgqAADAWAQVABet3PwibTmQp9z8IrtLAVAOvj0ZwEVpedZ3mrRyt9yW5OeQMgYlakiXWLvLAnCWSh9RSU1N1UcffVQdtQCAT+TmF3lCiiS5LemRlXs4sgIYqNJBJT8/X8nJyWrRooVmzJihQ4cOVUddAFBtsvNOeUJKqRLLUk5eoT0FAShXpYPK22+/rUOHDunee+/V8uXLFRcXpz59+mjFihVyuVzVUSMAVKn4iFD5ObzHnA6H4iJC7CkIQLl+12LayMhITZgwQZ9//rk++eQTXXbZZRo5cqSio6M1fvx47d+/v6rrBIAqExUerIxBiXI6zqQVp8OhGYPaKSo82ObKAJztDy2mzc3NVWZmpjIzM+V0OnXjjTdq9+7datOmjZ588kmNHz++quoEgCo1pEusureMVE5eoeIiQggpgKEqHVRcLpfeeecdLV68WOvWrVP79u2Vnp6u4cOHKywsTJK0atUqjR49mqACwGhR4cEEFMBwlQ4qUVFRcrvdGjZsmLZv366OHTuW2eb6669X/fr1q6A8AABwMat0UJkzZ44GDx6soKCgcrepX7++srOz/1BhAAAAlQ4qI0eOrI46AAAAyuAj9AEAgLEIKgAAwFgEFQAAYCyCCgAAMBZBBQAAGMuYoPLEE0/I4XAoPT3d7lIAAIAhjAgqWVlZeu6559S+fXu7SwEAAAaxPaj89NNPGjFihJ5//nk1aNDA7nIAAIBBbA8qaWlp6tu3r5KTk+0uBQAAGOYPfXvyH/XGG29o165dysrKqtD2xcXFKi4u9twuKCiQdOaLEl0uV5XWVjpfVc8Lb/TZN+izb9Bn36DPvlNdva7MfA7LsqwqffYKOnjwoJKSkpSZmelZm9KjRw917NhRc+fOPedjpk6dqmnTppUZX7ZsmUJCQqqzXAAAUEUKCws1fPhw5efnKyws7Lzb2hZU3n77bQ0cOFBOp9MzVlJSIofDIT8/PxUXF3vdJ537iEpMTIzy8vIu+EIry+VyKTMzU7169ZK/v3+Vzo1f0WffoM++QZ99gz77TnX1uqCgQBERERUKKrad+unZs6d2797tNTZq1Ci1bt1af/nLX8qEFEkKDAxUYGBgmXF/f/9qe7NW59z4FX32DfrsG/TZN+iz71R1ryszl21BpV69emrXrp3XWGhoqBo1alRmHAAAXJxsv+oHAACgPLZe9XO2jRs32l0CAAAwCEdUAACAsQgqAADAWAQVAABgLIIKAAAwFkEFAAAYi6ACAACMRVABAADGIqgAAABjEVQAAICxCCqAD+XmF2nLgTzl5hfZXQoA1AhGfYQ+UJstz/pOk1bultuS/BxSxqBEDekSa3dZAGA0jqgAPpCbX+QJKZLktqRHVu7hyAoAXABBBfCB7LxTnpBSqsSylJNXaE9BAFBDEFQAH4iPCJWfw3vM6XAoLiLEnoIAoIYgqAA+EBUerIxBiXI6zqQVp8OhGYPaKSo82ObKAMBsLKYFfGRIl1h1bxmpnLxCxUWEEFIAoAIIKoAPRYUHE1AAoBI49QMAAIxFUAEAAMYiqAAAAGMRVAAAgLEIKgAAwFgEFQAAYCyCCgAAMBZBBQAAGIugAgAAjEVQAQAAxiKoAAAAYxFUAACAsQgqAADAWAQVAABgLIIKAAAwFkEFAAAYi6ACAACMRVABAADGIqgAAABjEVQAAICxCCoAAMBYBBUAAGAsggoAADAWQQUAABiLoAIAAIxFUAEAAMYiqAAAAGMRVAAAgLEIKgAAwFgEFQAAYCyCCgAAMBZBBQAAGIugAgAAjEVQAQAAxiKoAAAAYxFUAACAsQgqAADAWAQVAABgLIIKAAAwFkEFAAAYy9agkpGRoS5duqhevXpq3LixBgwYoH379tlZEgAAMIitQWXTpk1KS0vTtm3blJmZKZfLpd69e+vUqVN2lgUAAAxRx84n/9e//uV1e8mSJWrcuLF27typ7t2721QVAAAwhVFrVPLz8yVJDRs2tLkSAABgAluPqPyW2+1Wenq6unXrpnbt2p1zm+LiYhUXF3tuFxQUSJJcLpdcLleV1lM6X1XPC2/02Tfos2/QZ9+gz75TXb2uzHwOy7KsKn323+nee+/V2rVrtXnzZjVr1uyc20ydOlXTpk0rM75s2TKFhIRUd4kAAKAKFBYWavjw4crPz1dYWNh5tzUiqIwdO1arV6/WRx99pPj4+HK3O9cRlZiYGOXl5V3whVaWy+VSZmamevXqJX9//yqdG7+iz75Bn32DPvsGffad6up1QUGBIiIiKhRUbD31Y1mWxo0bp1WrVmnjxo3nDSmSFBgYqMDAwDLj/v7+1fZmrc658Sv67Bv02Tfos2/QZ9+p6l5XZi5bg0paWpqWLVum1atXq169ejpy5IgkKTw8XMHBwXaWBgAADGDrVT8LFixQfn6+evTooaioKM/P8uXL7SwLAAAYwvZTPwAAAOUx6nNUAAAAfougAgAAjEVQAQAAxiKoAAAAYxFUAACAsQgqqBFy84u05UCecvOL7C4FAOBDxnwpIVCe5VnfadLK3XJbkp9DyhiUqCFdYu0uCwDgAxxRgdFy84s8IUWS3Jb0yMo9HFkBgIsEQQVGy8475QkppUosSzl5hfYUBADwKYIKjBYfESo/h/eY0+FQXESIPQUBAHyKoAKjRYUHK2NQopyOM2nF6XBoxqB2igrnSysB4GLAYloYb0iXWHVvGamcvELFRYQQUgDgIkJQQY0QFR5MQAGAixCnfgAAgLEIKgAAwFgEFQAAYCyCCgAAMBZBBQAAGIugAgAAjEVQAQAAxiKoAAAAYxFUAACAsQgqAADAWAQVAABgLIIKAAAwFkEFAAAYi6ACAACMRVABAADGIqgAAABjEVQAAICxCCoAAMBYBBUAAGAsggoAADAWQQUAABiLoAIAAIxFUCnH0YKfvf4EAAC+R1A5h+VZ36nXnE2SpF5zNml51nc2VwQAwMWJoHKW3PwiTVq5W27rzG23JT2yco9y84vsLQwAgIsQQeUs2XmnPCGlVIllKSev0J6CAAC4iBFUzhIfESo/h/eY0+FQXESIPQUBAHARI6icJSo8WBmDEuV0nEkrTodDMwa1U1R4sM2VAQBw8aljdwEmGtIlVt0ubaCdmz/UuvHd1axRPbtLAgDgosQRlXI0CQvy+hMAAPgeQQUAABiLoAIAAIxFUAEAAMYiqAAAAGMRVAAAgLEIKgAAwFgEFQAAYCyCCgAAMBZBBQAAGIugAgAAjEVQAQAAxiKoAAAAYxFUAACAsQgqAADAWEYElfnz5ysuLk5BQUG64oortH37drtLAgAABrA9qCxfvlwTJkzQlClTtGvXLnXo0EEpKSk6duyY3aUBAACb2R5UZs+erTFjxmjUqFFq06aNFi5cqJCQEL300kt2lwYAAGxWx84nP336tHbu3KlJkyZ5xvz8/JScnKytW7eW2b64uFjFxcWe2wUFBZIkl8sll8tVpbWVzlfV88IbffYN+uwb9Nk36LPvVFevKzOfrUElLy9PJSUlatKkidd4kyZNtHfv3jLbZ2RkaNq0aWXG161bp5CQkGqpMTMzs1rmhTf67Bv02Tfos2/QZ9+p6l4XFhZWeFtbg0plTZo0SRMmTPDcLigoUExMjHr37q2wsLAqfS6Xy6XMzEz16tVL/v7+VTo3fkWffYM++wZ99g367DvV1evSMyIVYWtQiYiIkNPp1NGjR73Gjx49qqZNm5bZPjAwUIGBgWXG/f39q+3NWp1z41f02Tfos2/QZ9+gz75T1b2uzFy2LqYNCAhQ586d9cEHH3jG3G63PvjgA1111VU2VgYAAExg+6mfCRMmKDU1VUlJSeratavmzp2rU6dOadSoUXaXBgAAbGZ7UBkyZIiOHz+uRx99VEeOHFHHjh31r3/9q8wCWwAAcPGxPahI0tixYzV27Fi7ywAAAIax/QPfAAAAykNQAQAAxiKoAAAAYxFUAACAsQgqAADAWAQVAABgLIIKAAAwFkGllsvNL9KWA3nKzS+yuxQAACrNiA98Q/VYnvWdJq3cLbcl+TmkjEGJGtIl1u6yAACoMI6o1FK5+UWekCJJbkt6ZOUejqwAAGoUgkotlZ13yhNSSpVYlnLyCu0pCACA34GgUkvFR4TKz+E95nQ4FBcRYk9BAAD8DgSVWioqPFgZgxLldJxJK06HQzMGtVNUeLDNlQEAUHEspq3FhnSJVfeWkcrJK1RcRAghBQBQ4xBUarmo8GACCgCgxuLUDwAAMBZBBQAAGIugAgAAjEVQAQAAxiKoAAAAYxFUAACAsQgqAADAWAQVAABgLIIKAAAwFkEFAAAYi6ACAACMVaO/68eyLElSQUFBlc/tcrlUWFiogoIC+fv7V/n8OIM++wZ99g367Bv02Xeqq9el++3S/fj51OigcvLkSUlSTEyMzZUAAIDKOnnypMLDw8+7jcOqSJwxlNvt1uHDh1WvXj05HI4qnbugoEAxMTE6ePCgwsLCqnRu/Io++wZ99g367Bv02Xeqq9eWZenkyZOKjo6Wn9/5V6HU6CMqfn5+atasWbU+R1hYGL8IPkCffYM++wZ99g367DvV0esLHUkpxWJaAABgLIIKAAAwFkGlHIGBgZoyZYoCAwPtLqVWo8++QZ99gz77Bn32HRN6XaMX0wIAgNqNIyoAAMBYBBUAAGAsggoAADAWQQUAABiLoHIO8+fPV1xcnIKCgnTFFVdo+/btdpdU62RkZKhLly6qV6+eGjdurAEDBmjfvn12l1WrPfHEE3I4HEpPT7e7lFrp0KFDuv3229WoUSMFBwcrMTFRO3bssLusWqWkpESTJ09WfHy8goODlZCQoL/97W8V+r4YlO+jjz5S//79FR0dLYfDobffftvrfsuy9OijjyoqKkrBwcFKTk7W/v37fVYfQeUsy5cv14QJEzRlyhTt2rVLHTp0UEpKio4dO2Z3abXKpk2blJaWpm3btikzM1Mul0u9e/fWqVOn7C6tVsrKytJzzz2n9u3b211KrXTixAl169ZN/v7+Wrt2rb788kvNmjVLDRo0sLu0WmXmzJlasGCBnnnmGf373//WzJkz9eSTT2revHl2l1ajnTp1Sh06dND8+fPPef+TTz6pp59+WgsXLtQnn3yi0NBQpaSk6Oeff/ZNgRa8dO3a1UpLS/PcLikpsaKjo62MjAwbq6r9jh07ZkmyNm3aZHcptc7JkyetFi1aWJmZmdZ1111nPfDAA3aXVOv85S9/sa655hq7y6j1+vbta40ePdprbNCgQdaIESNsqqj2kWStWrXKc9vtdltNmza1nnrqKc/Yjz/+aAUGBlqvv/66T2riiMpvnD59Wjt37lRycrJnzM/PT8nJydq6dauNldV++fn5kqSGDRvaXEntk5aWpr59+3q9r1G13nnnHSUlJWnw4MFq3LixOnXqpOeff97usmqdq6++Wh988IG++uorSdLnn3+uzZs3q0+fPjZXVntlZ2fryJEjXv9+hIeH64orrvDZfrFGfylhVcvLy1NJSYmaNGniNd6kSRPt3bvXpqpqP7fbrfT0dHXr1k3t2rWzu5xa5Y033tCuXbuUlZVldym12jfffKMFCxZowoQJeuSRR5SVlaX7779fAQEBSk1Ntbu8WuPhhx9WQUGBWrduLafTqZKSEk2fPl0jRoywu7Ra68iRI5J0zv1i6X3VjaAC26WlpWnPnj3avHmz3aXUKgcPHtQDDzygzMxMBQUF2V1OreZ2u5WUlKQZM2ZIkjp16qQ9e/Zo4cKFBJUq9Oabb2rp0qVatmyZ2rZtq88++0zp6emKjo6mz7UYp35+IyIiQk6nU0ePHvUaP3r0qJo2bWpTVbXb2LFjtWbNGm3YsEHNmjWzu5xaZefOnTp27Jj+67/+S3Xq1FGdOnW0adMmPf3006pTp45KSkrsLrHWiIqKUps2bbzGLr/8cn333Xc2VVQ7TZw4UQ8//LCGDh2qxMREjRw5UuPHj1dGRobdpdVapfs+O/eLBJXfCAgIUOfOnfXBBx94xtxutz744ANdddVVNlZW+1iWpbFjx2rVqlX68MMPFR8fb3dJtU7Pnj21e/duffbZZ56fpKQkjRgxQp999pmcTqfdJdYa3bp1K3N5/VdffaXmzZvbVFHtVFhYKD8/792W0+mU2+22qaLaLz4+Xk2bNvXaLxYUFOiTTz7x2X6RUz9nmTBhglJTU5WUlKSuXbtq7ty5OnXqlEaNGmV3abVKWlqali1bptWrV6tevXqec53h4eEKDg62ubraoV69emXW/ISGhqpRo0asBapi48eP19VXX60ZM2botttu0/bt27Vo0SItWrTI7tJqlf79+2v69OmKjY1V27Zt9emnn2r27NkaPXq03aXVaD/99JO+/vprz+3s7Gx99tlnatiwoWJjY5Wenq7HH39cLVq0UHx8vCZPnqzo6GgNGDDANwX65NqiGmbevHlWbGysFRAQYHXt2tXatm2b3SXVOpLO+bN48WK7S6vVuDy5+rz77rtWu3btrMDAQKt169bWokWL7C6p1ikoKLAeeOABKzY21goKCrIuvfRS669//atVXFxsd2k12oYNG87573FqaqplWWcuUZ48ebLVpEkTKzAw0OrZs6e1b98+n9XnsCw+0g8AAJiJNSoAAMBYBBUAAGAsggoAADAWQQUAABiLoAIAAIxFUAEAAMYiqAAAAGMRVAAAgLEIKgAAwFgEFQAAYCyCCgBjHD9+XE2bNtWMGTM8Y1u2bFFAQIDXt7cCuHjwXT8AjPLee+9pwIAB2rJli1q1aqWOHTvq5ptv1uzZs+0uDYANCCoAjJOWlqb169crKSlJu3fvVlZWlgIDA+0uC4ANCCoAjFNUVKR27drp4MGD2rlzpxITE+0uCYBNWKMCwDgHDhzQ4cOH5Xa7lZOTY3c5AGzEERUARjl9+rS6du2qjh07qlWrVpo7d652796txo0b210aABsQVAAYZeLEiVqxYoU+//xz1a1bV9ddd53Cw8O1Zs0au0sDYANO/QAwxsaNGzV37ly9+uqrCgsLk5+fn1599VX93//9nxYsWGB3eQBswBEVAABgLI6oAAAAYxFUAACAsQgqAADAWAQVAABgLIIKAAAwFkEFAAAYi6ACAACMRVABAADGIqgAAABjEVQAAICxCCoAAMBYBBUAAGCs/wc1kFJHtMBONwAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "x = np.linspace(0, 10, 10)          # Generate 10 random x values\n",
    "y = x + np.random.normal(0, 1, 10)  # Add noise\n",
    "\n",
    "# Plot\n",
    "plt.scatter(x, y, marker='.')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.title('Plot of y = x + Gaussian noise')\n",
    "plt.grid(True)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, let's plot the least squares fit using the 10th degree Polynomial basis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\pthomas\\AppData\\Local\\Temp\\ipykernel_6512\\3960549941.py:2: RankWarning: Polyfit may be poorly conditioned\n",
      "  coefficients = np.polyfit(x, y, 10)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Perform a least squares fit with a 10th degree polynomial basis\n",
    "coefficients = np.polyfit(x, y, 10)\n",
    "polynomial_fit = np.polyval(coefficients, np.linspace(0, 10, 100))\n",
    "\n",
    "# Plotting the points as dots and the polynomial fit curve\n",
    "plt.scatter(x, y, marker='.')\n",
    "plt.plot(np.linspace(0, 10, 100), polynomial_fit, color='red')  # Polynomial fit curve\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.title('10th Degree Polynomial Fit to Points with Gaussian Noise')\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This polynomial achieves a training error of zero - it goes precisely through each point! However, the test error will not be zero (remember, these are points from $y=x$ with Gausssian noise added). Here is the least squares linear fit:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Perform a linear fit (least squares)\n",
    "linear_coefficients = np.polyfit(x, y, 1)\n",
    "linear_fit = np.polyval(linear_coefficients, x)\n",
    "\n",
    "# Plotting the points as dots, the linear fit, and the polynomial fit curve\n",
    "plt.scatter(x, y, marker='.')\n",
    "plt.plot(x, linear_fit, color='green', label='Linear Fit')  # Linear fit line\n",
    "plt.plot(np.linspace(0, 10, 100), polynomial_fit, color='red', label='10th Degree Polynomial Fit')  # Polynomial fit curve\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('y')\n",
    "plt.title('Linear and 10th Degree Polynomial Fit to Points with Gaussian Noise')\n",
    "plt.legend()\n",
    "plt.grid(True)\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}